Graphical user interface (GUI) systems present information to the user in a graphical format using windows, toolbar displays, icons, and graphics. One of the goals of GUI systems is to present information needed by the user in a pleasant and apparent manner so that the user is more inclined to utilize the functions of the underlying software without having to memorize many commands. For example, to move the location of a file using a GUI system, a user may only have to select a file and then drag it to the desired folder or other location. The user is not required to remember any text commands but is performing an activity, e.g., moving a file, by performing a natural or familiar function, e.g., selecting the file and moving it to the preferred destination.
As software becomes more complex and provides more functionality, the design of a GUI becomes increasingly more difficult for software developers. Typically, this additional complexity and functionality results in the presentation of more commands to the user so that the user can take advantage of the additional functionality. In general, the goal of designing a GUI is to present commands to the user that are useful without being confusing. When the number of commands to be presented to the user increases, it becomes more difficult to present commands in a user-friendly interface without overwhelming the user with multiple layers of buttons, menus and graphics.
Software designers have addressed this problem by creating menus and toolbar displays in the GUI that can comprise multiple commands or control items in a minimal amount of display area, thereby increasing the density of the commands easily available to the user. Menus present commands in a pull-down fashion allowing multiple command access from a single point on the display. Toolbars contain controls, which are typically displayed on toolbar displays constantly on a screen for easy access. Because toolbar displays are, generally, permanently displayed on the screen, the controls in the toolbar are, ideally, those controls used most often by the user. For example, a toolbar display in a word processing application may present Character Style controls (e.g., Bold, Italics and Underline) of the corresponding toolbar because these style attributes are used often during a word processing session. Usually, however, the determination of which controls are most important is done by software designers--not the users--in anticipation of possible user needs.
The utilization of toolbar displays has created a dilemma for software designers. There are many commands that are often used by the user but designers are constrained to limited toolbar display space. The toolbar display space is limited because displaying too many controls will cut into the workspace display area for the application. In addition, placing too many controls in front of the user becomes confusing, counteracting the goal of the GUI.
There have been several approaches for addressing the problem of presenting too many commands to a user on a toolbar display. One approach merely truncates the toolbar display on the right side of the display where it runs out of display space. Controls in the truncated area are just not accessible to the user. The user cannot access the truncated area of the toolbar display unless the toolbar display size is increased (i.e., such as by increasing the window size).
Another approach allows multiple toolbar displays to share display space in a window, thereby maximizing the amount of workspace display while still giving users access to the commands contained in the toolbar display. Because the toolbar displays share space, their display area is reduce thereby reducing the number of controls that can be displayed at any one time. Controls not displayed in the toolbar display can be accessed by using a special control item, which allows the user to page through the available controls for the corresponding toolbar on the toolbar display. However, when a user wishes to use a control that is not displayed, the user is required to page through the available controls each time until the desired control is displayed and then select it. This may require the user to constantly page through the toolbar display to access the controls, independent of when or how often the control is used.
A third approach does not allow multiple toolbar displays to share display space; however, this approach allows for the assignment of priorities to the various controls. When the toolbar display cannot display all of the available controls, the controls that are displayed are based on the assigned priority. However, this assigned priority is independent of the user's usage of the control. The priority is static and assigned to the controls by software developers and may only be altered through the use of a Visual Basic program, which most users are not sophisticated enough to perform.
And finally, several applications modify which controls are in the toolbar display based on a particular state the application is in or on what object is selected. The intent is to display the controls thought to be of value to the user. The determination of what is displayed in the toolbar is again dictated by the application or software designer, not the user.
Therefore, there is a need in the art for a method to display controls in a toolbar display that are most important to the user, based on the user's usage of the controls, while maximizing the available workspace in a window for use by the application. The method also will display the most important controls to the user, which may change dynamically throughout a session, and provide access to all the controls accessible through the toolbar display.